home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / lfslib / installed / lfslib.h < prev   
C/C++ Source or Header  |  1991-12-16  |  13KB  |  363 lines
  1. /*
  2.  * lfslib.h --
  3.  *
  4.  *    Declarations of user level routines for accessing LFS file system
  5.  *    data structures.  This routines should be used for recovery and
  6.  *    other programs that need scan an LFS file system.
  7.  *    
  8.  *
  9.  * Copyright 1990 Regents of the University of California
  10.  * Permission to use, copy, modify, and distribute this
  11.  * software and its documentation for any purpose and without
  12.  * fee is hereby granted, provided that the above copyright
  13.  * notice appear in all copies.  The University of California
  14.  * makes no representations about the suitability of this
  15.  * software for any purpose.  It is provided "as is" without
  16.  * express or implied warranty.
  17.  *
  18.  * $Header: /sprite/lib/forms/RCS/proto.h,v 1.5 90/01/12 12:03:25 douglis Exp $ SPRITE (Berkeley)
  19.  */
  20.  
  21. #ifndef _LFSLIB
  22. #define _LFSLIB
  23.  
  24. #if defined(__STDC__) || defined(SABER)
  25. /*
  26.  * Enable the function prototypes for standard C compilers. They also
  27.  * work when using SaberC.
  28.  */
  29. #define _HAS_PROTOTYPES
  30. #endif
  31.  
  32. #include <cfuncproto.h>
  33. #include <sprite.h>
  34. #include <bit.h>
  35. #include <fs.h>
  36. #include <list.h>
  37. #include <kernel/fs.h>
  38. #include <kernel/dev.h>
  39. #include <kernel/fsdm.h>
  40. #include <kernel/fslcl.h>
  41. #include <kernel/devDiskLabel.h>
  42. #include <kernel/lfsDesc.h>
  43. #include <kernel/lfsDescMap.h>
  44. #include <kernel/lfsFileLayout.h>
  45. #include <kernel/lfsDirOpLog.h>
  46. #include <kernel/lfsSegLayout.h>
  47. #include <kernel/lfsStableMem.h>
  48. #include <kernel/lfsSuperBlock.h>
  49. #include <kernel/lfsUsageArray.h>
  50. #include <kernel/lfsStats.h>
  51.  
  52. /* constants */
  53.  
  54. /* data structures */
  55. typedef struct LogPoint {
  56.     int    segNo;        /* LFS segment number. */
  57.     int blockOffset;    /* Block offset into segment. */
  58. } LogPoint;
  59.  
  60. /*
  61.  * LfsCheckPoint contains the info and memory needed to perform checkpoints.
  62.  * The file system timestamp and the next checkpoint area to write
  63.  * indicator are kept here. 
  64.  */
  65. typedef struct LfsCheckPoint {
  66.     int      timestamp;    /* Current file system timestamp. */
  67.     int      nextArea;    /* Next checkpoint area to write. Must be 0 or 1. */
  68.     char  *buffer;    /* Memory buffer to place checkpoint. */
  69.     int      maxSize;    /* Maximum size of the buffer. */
  70. } LfsCheckPoint;
  71.  
  72. /*
  73.  * LfsSegLogRange describes the position in the segmented log of a segment. 
  74.  */
  75. typedef struct LfsSegLogRange {
  76.     int        current;    /* Current segment being accessed */
  77.     int        prevSeg;    /* The segment that was written before the
  78.                  * current segment. */
  79.     int        nextSeg;    /* Next segment to be written after the
  80.                  * current segment. */
  81. } LfsSegLogRange;
  82.  
  83. /*
  84.  * Data blocks are added to LfsSeg structures in units of LfsSegElement's.
  85.  */
  86. typedef struct LfsSegElement {
  87.     Address       address;         /* The address of the start of the buffer. */
  88.     unsigned int lengthInBlocks;  /* Length of the buffer in units of file 
  89.                    * system blocks. */
  90.     ClientData   clientData;      /* ClientData usable by the callback 
  91.                    * functions. */
  92. } LfsSegElement;
  93.  
  94.  
  95. typedef struct LfsDescMap {
  96.     LfsDescMapCheckPoint checkPoint;
  97.     ClientData        smemPtr;
  98. } LfsDescMap;
  99.  
  100. typedef struct LfsSegUsage {
  101.     LfsSegUsageCheckPoint checkPoint;
  102.     ClientData        smemPtr;
  103. } LfsSegUsage;
  104.  
  105. typedef struct LfsFileLayout {
  106.     List_Links    activeFileListHdr;
  107. } LfsFileLayout;
  108.  
  109. /*
  110.  * Lfs - the main data structured used by these library routines to access
  111.  *      an LFS file system.
  112.  */
  113. typedef struct Lfs {
  114.     int        diskFd;            /* Open file descriptor of LFS disk. */
  115.     ClientData    diskCache;        /* Cache of disk blocks. */
  116.     int        superBlockOffset;    /* Offset of the super block. */
  117.     char    *deviceName;        /* Name of the device with LFS. */
  118.     char    *programName;        /* Name of program being run. */
  119.  
  120.     LfsSuperBlock superBlock; /* The superblock of the file system */
  121.     LfsCheckPoint checkPoint;   /* Checkpoint data. */
  122.  
  123.     LfsCheckPointHdr    *checkPointHdrPtr;  /* Current checkpoint header. */
  124.     char      *name;        /* Name used for error messages. */
  125.     Lfs_Stats    stats;        /* Current stats. */
  126.     LfsDescMap      descMap;    /* Descriptor map data. */
  127.     LfsSegUsage   usageArray;   /* Segment usage array data. */
  128.     LfsFileLayout fileLayout;    /* File layout data structures. */
  129.     LogPoint    logEnd;                    /* End of log. */
  130.     struct { 
  131.     int blocksReadDisk;        /* Number of blocks read from disk. */
  132.     int blocksWrittenDisk;      /* Number of blocks written to disk. */
  133.     int writeSummaryBlock;        /* Summary blocks written. */
  134.     int segUsageBlockWrite;        /* Seg usage block written. */
  135.     int descMapBlockWrite;        /* Desc map block written. */
  136.     int fileWritten;        /* Number of files written. */
  137.     int fileBlockWritten;        /* File blocks (512) written. */
  138.     int descWritten;        /* Number of desc written. */
  139.     } pstats;            /* Program stats. */
  140. } Lfs;
  141.  
  142. /*
  143.  * Structure used to address segments on disk.
  144.  */
  145. typedef struct LfsSeg {
  146.     Lfs      *lfsPtr;        /* File system of segemnt. */
  147.     int      segNo;        /* Segment number. */
  148.     LfsSegElement *segElementPtr; /* The SegElements making up the data 
  149.                    * region of the segment. */
  150.     char       *memPtr;    /* Segment memory allocated for segment. */
  151.     LfsSegLogRange logRange;    /* Placement of segment in segmented log. */
  152.     int        numElements;      /* Number of LfsSegElement describing the 
  153.                    * segment. */
  154.     int        numBlocks;        /* Number of blocks in segment. */
  155.     int        startBlockOffset; /* Starting block offset of this segment. */
  156.     int        activeBytes;      /* Number of active bytes in segment. */
  157.     /*
  158.      * Some operations of segments require scanning thru the summary 
  159.      * and SegElements.  The following fields keep the start require
  160.      * from this scans. 
  161.      */
  162.     LfsSegSummary    *curSegSummaryPtr; /* Summary of current summary 
  163.                         * block. */
  164.     LfsSegSummaryHdr    *curSummaryHdrPtr; 
  165.                 /* Current module header being processed. */
  166.     int         curElement;    /* Current LfsSegElement. */
  167.     int         curBlockOffset;    /* The block offset into the segment of the
  168.                  * end of curElement. */
  169.     int         curDataBlockLimit;   /* Last block offset available in the 
  170.                    * segment. */
  171.     char     *curSummaryPtr;    /* Current offset into the summary region. */
  172.     char     *curSummaryLimitPtr; /* Current last byte of the summary block 
  173.                    * plus 1. */
  174.  
  175. } LfsSeg;
  176.  
  177. /*
  178.  * Structure used to keep track of open and active files.
  179.  */
  180. typedef struct LfsFile {
  181.     List_Links    links;       /* For lists of files. MUST BE FIRST. */
  182.     Lfs        *lfsPtr;   /* File system of file. */
  183.     LfsFileDescriptor desc; /* Copy of file's file descriptor. */
  184.     List_Links    blockListHdr; /* Header for list of file's blocks in memory. */
  185.     Boolean    descModified; /* The descriptor was modified. */
  186.     Boolean    beingWritten;    /* The file is being written. */
  187. } LfsFile;
  188.  
  189. typedef struct LfsFileBlock {
  190.     List_Links    links;       /* For lists of blocks. MUST BE FIRST. */
  191.     LfsFile    *filePtr;  /* File in which this block resides. */
  192.     int        blockNum;  /* Block number in file. */
  193.     int        blockSize; /* Size of the block in bytes. */
  194.     int        blockAddr; /* Block disk address of this block. FSDM_NIL_INDEX
  195.                 * if the block hasn't been allocated to disk yet. */
  196.     Boolean    modified;  /* The block has been modified in memory. */
  197.     char    contents[FS_BLOCK_SIZE]; /* The contents of the block. */
  198. } LfsFileBlock;
  199. /*
  200.  * Macros
  201.  */
  202. /*
  203.  *    LfsGetDescMapEntry() - Return the descriptor map entry for a file number.
  204.  *    LfsGetUsageArrayEntry() - Return an usage array entry for a segment number.
  205.  *    LfsGetDescMapBlockIndex() - Return the block index of a desc map block.
  206.  *    LfsGetUsageArrayBlockIndex() - Return the block index of a usage array block.
  207.  *    
  208.  */
  209.  
  210. #define    LfsGetDescMapEntry(lfsPtr, fileNumber) \
  211.   ((LfsDescMapEntry *) LfsGetStableMemEntry((lfsPtr)->descMap.smemPtr, fileNumber))
  212. #define    LfsDescMapEntryModified(lfsPtr, fileNumber) \
  213.    (LfsMarkStableMemEntryDirty((lfsPtr)->descMap.smemPtr, fileNumber))
  214. #define    LfsGetUsageArrayEntry(lfsPtr, segNo) \
  215.    ((LfsSegUsageEntry *) LfsGetStableMemEntry((lfsPtr)->usageArray.smemPtr, segNo))
  216. #define    LfsUsageArrayEntryModified(lfsPtr, segNo) \
  217.     (LfsMarkStableMemEntryDirty((lfsPtr)->usageArray.smemPtr, segNo))
  218.  
  219. #define LfsGetDescMapBlockIndex(lfsPtr, blockNum) \
  220.     LfsGetStableMemBlockIndex((lfsPtr)->descMap.smemPtr, blockNum)
  221. #define LfsGetUsageArrayBlockIndex(lfsPtr, blockNum) \
  222.     LfsGetStableMemBlockIndex((lfsPtr)->usageArray.smemPtr, blockNum)
  223.  
  224.  
  225. #define    LfsFileFetchDesc(filePtr) (&((filePtr)->desc))
  226. #define    LfsFileBlockMem(fileBlockPtr)    ((fileBlockPtr)->contents)
  227. #define    LfsFileBlockSize(fileBlockPtr)    ((fileBlockPtr)->blockSize)
  228. #define    LfsFileBlockAddress(fileBlockPtr)    ((fileBlockPtr)->blockAddr)
  229.  
  230.  
  231. /* Useful macros for LFS.
  232.  *
  233.  * LfsSegSize(lfsPtr)    - Return the segment size in bytes.
  234.  * LfsSegSizeInBlocks(lfsPtr) - Return the segment size in blocks.
  235.  * LfsBlockSize(lfsPtr)       - Return the block size.
  236.  * LfsBytesToBlocks(lfsPtr, bytes) - Convert bytes into the number of blocks
  237.  *                     it would take to contain the bytes.
  238.  * LfsBlocksToBytes(lfsPtr, blocks) - Convert from blocks into bytes.
  239.  * LfsSegNumToDiskAddress(lfsPtr, segNum) - Convert a segment number into
  240.  *                        a disk address.
  241.  * LfsBlockToSegmentNum(lfsPtr, diskAdress)  - Compute the segment number 
  242.  *
  243.  * LfsGetCurrentTimestamp(lfsPtr) - Return the current file system timestamp
  244.  */
  245.  
  246.  
  247. #define    LfsBlockSize(lfsPtr) ((lfsPtr)->superBlock.hdr.blockSize)
  248. #define    LfsSegSize(lfsPtr) ((lfsPtr)->superBlock.usageArray.segmentSize)
  249.  
  250. #define    LfsSegSizeInBlocks(lfsPtr) (LfsSegSize(lfsPtr)/LfsBlockSize(lfsPtr))
  251.  
  252.  
  253. #define    LfsBytesToBlocks(lfsPtr, bytes)    \
  254.      (((bytes) + (LfsBlockSize(lfsPtr)-1))/LfsBlockSize(lfsPtr))
  255.  
  256. #define    LfsBlocksToBytes(lfsPtr, blocks) ((blocks)*LfsBlockSize(lfsPtr))
  257.  
  258.  
  259. #define LfsValidSegmentNum(lfsPtr, segNum) (((segNum) >= 0) && \
  260.         ((segNum) < (lfsPtr)->superBlock.usageArray.numberSegments))
  261.  
  262.  
  263. #define LfsSegNumToDiskAddress(lfsPtr, segNum) \
  264.              (((lfsPtr)->superBlock.hdr.logStartOffset + \
  265.         (LfsSegSizeInBlocks((lfsPtr)) * (segNum))))
  266.  
  267. #define LfsDiskAddrToSegmentNum(lfsPtr, diskAddress) \
  268.         (((diskAddress) - \
  269.                 (lfsPtr)->superBlock.hdr.logStartOffset) / \
  270.                      LfsSegSizeInBlocks((lfsPtr)))
  271.  
  272. #define    LfsGetCurrentTimestamp(lfsPtr)    (++((lfsPtr)->checkPoint.timestamp))
  273.  
  274.  
  275. /* procedures */
  276.  
  277. extern Lfs *LfsLoadFileSystem _ARGS_((char *programName, char *deviceName, 
  278.         int blockSize, int  superBlockOffset, int flags));
  279.  
  280. extern int LfsGetStableMemBlockIndex _ARGS_((ClientData clientData, int blockNum));
  281. extern char *LfsGetStableMemEntry _ARGS_((ClientData clientData, int entryNumber));
  282.  
  283. extern void LfsMarkStableMemEntryDirty _ARGS_((ClientData clientData, 
  284.                     int entryNumber));
  285.  
  286. extern int LfsDiskRead _ARGS_((Lfs *lfsPtr, int blockOffset, int bufferSize, 
  287.                 char *bufferPtr));
  288.  
  289. extern int LfsDiskWrite _ARGS_((Lfs *lfsPtr, int blockOffset, int bufferSize, 
  290.                 char *bufferPtr));
  291.  
  292. extern void LfsDiskCache _ARGS_((Lfs *lfsPtr, int maxCacheBytes));
  293.  
  294. extern void LfsDiskCacheInvalidate _ARGS_((Lfs *lfsPtr, int blockOffset, 
  295.                     int blockSize));
  296.  
  297. extern LfsSeg *LfsSegInit _ARGS_((Lfs *lfsPtr, int segNumber));
  298. extern int LfsSegStartAddr _ARGS_((LfsSeg *segPtr));
  299. extern char *LfsSegFetchBlock _ARGS_((LfsSeg *segPtr, int blockOffset, int size));
  300. extern void LfsSegReleaseBlock _ARGS_((LfsSeg *segPtr, char *memPtr));
  301. extern void LfsSegRelease _ARGS_((LfsSeg *segPtr));
  302.  
  303. extern ReturnStatus LfsFileOpen _ARGS_((Lfs *lfsPtr, int fileNumber,
  304.                      LfsFile **filePtrPtr));
  305. extern ReturnStatus LfsFileOpenDesc _ARGS_((Lfs *lfsPtr, 
  306.             LfsFileDescriptor *descPtr, LfsFile **filePtrPtr));
  307. extern void        LfsFileClose _ARGS_((LfsFile *filePtr));
  308.  
  309. extern ReturnStatus LfsFileBlockFetch _ARGS_((LfsFile *filePtr, int blockNum, 
  310.                 LfsFileBlock **fileBlockPtrPtr));
  311.  
  312. extern ReturnStatus LfsFileBlockAlloc _ARGS_((LfsFile *filePtr, int blockNum, 
  313.             int blocksize,     LfsFileBlock **fileBlockPtrPtr));
  314.  
  315. extern int LfsFileBlockAddr _ARGS_((LfsFile *filePtr, int blockNum,
  316.                      int *blocksizePtr));
  317.  
  318. extern ReturnStatus LfsFileStoreDesc _ARGS_((LfsFile *filePtr));
  319.  
  320. extern ReturnStatus LfsFileStoreBlock _ARGS_((LfsFileBlock *fileBlockPtr,
  321.                         int newSize));
  322.  
  323. extern ReturnStatus LfsFileAddToDirectory _ARGS_((LfsFile *dirFilePtr, 
  324.                          LfsFile *filePtr, 
  325.                          char *name));
  326.  
  327. extern ReturnStatus LfsFileNameLookup _ARGS_((LfsFile *dirFilePtr, 
  328.                          char *name,
  329.                          int *fileNumberPtr, 
  330.                          int *dirOffsetPtr));
  331.  
  332. extern void LfsSegUsageAdjustBytes _ARGS_((Lfs *lfsPtr, int diskAddr, 
  333.                     int changeInBytes));
  334.  
  335.  
  336.  
  337. extern ReturnStatus LfsDescMapGetVersion _ARGS_((struct Lfs *lfsPtr,
  338.             int fileNumber, unsigned short *versionNumPtr));
  339. extern ReturnStatus LfsDescMapGetDiskAddr _ARGS_((struct Lfs *lfsPtr, 
  340.             int fileNumber, LfsDiskAddr *diskAddrPtr));
  341. extern ReturnStatus LfsDescMapSetDiskAddr _ARGS_((struct Lfs *lfsPtr, 
  342.             int fileNumber, LfsDiskAddr diskAddr));
  343. extern ReturnStatus LfsDescMapGetAccessTime _ARGS_((struct Lfs *lfsPtr,
  344.             int fileNumber, int *accessTimePtr));
  345. extern ReturnStatus LfsDescMapSetAccessTime _ARGS_((struct Lfs *lfsPtr, 
  346.             int fileNumber, int accessTime));
  347.  
  348. extern ReturnStatus LfsGetNewFileNumber _ARGS_((struct Lfs *lfsPtr, 
  349.             int dirFileNumber, int *fileNumberPtr));
  350.  
  351.  
  352. extern ReturnStatus LfsGetLogTail _ARGS_((struct Lfs *lfsPtr, Boolean cantWait,
  353.             LfsSegLogRange *logRangePtr, int *startBlockPtr ));
  354.  
  355. extern void LfsSetLogTail _ARGS_((struct Lfs *lfsPtr, 
  356.             LfsSegLogRange *logRangePtr, int startBlock, 
  357.             int activeBytes));
  358.  
  359. extern ReturnStatus LfsCheckPointFileSystem _ARGS_((Lfs *lfsPtr, int flags));
  360.  
  361. #endif /* _LFSLIB */
  362.  
  363.